import org.junit.Test;
import org.junit.experimental.max.MaxCore;
import org.omg.PortableInterceptor.ServerRequestInfo;

import javax.swing.plaf.basic.BasicOptionPaneUI;
import java.util.*;

public class leetCodeResult {

    @Test
    public void doIt() {
        int[] param = {3, -1, -5, -9, 0, 2, 4, 6, 8, 7};
//        char[][] paramer = {{'1','0','1','0','0'},{'1','0','1','1','1'},{'1','1','1','1','1'},{'1','0','0','1','0'}};
//        String parmas = "111111111111111111111111111111111111111111111";
//        int test = maximalSquare(paramer);
//        System.out.println(test);
        quick_sort(param, 0, param.length - 1);
        return;
    }

    public int[] quick_sort(int[] num, int begin, int end) {
        if (begin == end) {
            return num;
        }
        int i = begin;
        int j = end;
        int s = num[i];
        boolean flag = true;
        while (true) {
            //从右往左找
            if (flag) {
                if (s > num[j]) {
                    int n = num[j];
                    num[j] = num[i];
                    num[i] = n;
                    flag = false;
                } else {
                    j--;
                }
            }
            //从左往右找
            if (!flag) {
                if (s < num[i]) {
                    int n = num[i];
                    num[i] = num[j];
                    num[j] = n;
                    flag = true;
                } else {
                    i++;
                }
            }
            if (i == j) {
                break;
            }
        }
        if (i != begin) {
            quick_sort(num, begin, i);
        }
        if (j != end) {
            quick_sort(num, j + 1, end);
        }

//        List<Integer> array = new ArrayList();

        return num;
    }

    /**
     * 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
     * <p>
     * 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
     * <p>
     * 来源：力扣（LeetCode）
     * 链接：
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     *
     * @param m
     * @param n
     * @return
     */
    public int uniquePaths(int m, int n) {
        if (m == 0 || n == 0) {
            return 1;
        }
        //建立二维数组，用作网格来记录动态规划过程
        int gridTable[][] = new int[m][n];
        //初始化最右边一列
        for (int i = 0; i < m; i++) {
            gridTable[i][n - 1] = 1;
        }
        //初始化最底下一行
        for (int i = 0; i < n; i++) {
            gridTable[m - 1][i] = 1;
        }
        //从倒数第一行开始，从右往左填充值。每个值都是右边和下边的和
        for (int i = m - 2; i >= 0; i--) {
            for (int j = n - 2; j >= 0; j--) {
                gridTable[i][j] = gridTable[i][j + 1] + gridTable[i + 1][j];
            }
        }
        return gridTable[0][0];
    }

    /**
     * 64. 最小路径和
     * 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
     *
     * @param grid
     * @return 动态规划解法，和上边的机器人走格子题很像
     */
    public int minPathSum(int[][] grid) {
        int n = grid[0].length;
        if (n == 0) {
            return 0;
        }
        int m = grid.length;

        //建立二维数组，用作网格，来记录每个格子走法的数字和最小的值
        int gridTable[][] = new int[m][n];
        //初始化网格的第一行和第一列
        gridTable[0][0] = grid[0][0];
        for (int i = 1; i < n; i++) {
            //初始化第一行
            gridTable[0][i] = gridTable[0][i - 1] + grid[0][i];
        }
        for (int i = 1; i < m; i++) {
            //初始化第一列
            gridTable[i][0] = gridTable[i - 1][0] + grid[i][0];
        }
        //从第二行第二个值开始赋值，每次赋值取左边和上边最小的值加自身的值
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                gridTable[i][j] = grid[i][j] + Math.min(gridTable[i - 1][j], gridTable[i][j - 1]);
            }
        }

        return gridTable[m - 1][n - 1];
    }

    /**
     * 509. 斐波那契数
     * 斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
     */
    public int fib(int n) {
        int result = -1;
        if (n < 0) {
            return 0;
        }
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        }
        int num1 = 0;
        int num2 = 1;
        int num3 = 0;
        for (int i = 2; i <= n; i++) {
            num3 = num1 + num2;
            num1 = num2;
            num2 = num3;
        }
        result = num3;
        return result;
    }

    /**
     * 1137. 第 N 个泰波那契数
     * 泰波那契序列 Tn 定义如下： 
     * <p>
     * T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
     * <p>
     * 给你整数 n，请返回第 n 个泰波那契数 Tn 的值。
     * <p>
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/n-th-tribonacci-number
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     *
     * @param n
     * @return
     */
    public int tribonacci(int n) {
        if (n < 0) {
            return 0;
        } else if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        } else if (n == 2) {
            return 1;
        }
        int result = -1;
        int a = 0;
        int b = 1;
        int c = 1;
        for (int i = 3; i <= n; i++) {
            result = a + b + c;
            a = b;
            b = c;
            c = result;
        }

        return result;
    }

    /**
     * 746. 使用最小花费爬楼梯
     * 数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
     * <p>
     * 每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。
     * <p>
     * 请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。
     */

    public int minCostClimbingStairs(int[] cost) {
        int result = 0;
        if (cost.length == 1) {
            result = cost[0];
            return result;
        } else if (cost.length == 2) {
            result = Math.min(cost[1], cost[0]);
            return result;
        }
        //代表到达cost[i-2]的最小值
        int p = 0;
        //代表到达cost[i-1]的最小值
        int q = 0;
        for (int i = 2; i <= cost.length; i++) {
            result = Math.min(p + cost[i - 2], q + cost[i - 1]);
            p = q;
            q = result;
        }
        return result;
    }

    /**
     * 198. 打家劫舍
     * 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
     * <p>
     * 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额
     */
    public int rob(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int a1 = nums[0];
        int a2 = nums[1];
        int a3 = 0;
        int result = 0;
        if (nums.length == 2) {
            return a1 > a2 ? a1 : a2;
        }
        if (nums.length == 3) {
            a3 = a1 + nums[2] > a2 ? a1 + nums[2] : a2;
            result = a3;
            return a3;
        }
        a3 = a1 + nums[2] > a2 ? a1 + nums[2] : a2;
        result = a3;
        for (int i = 3; i < nums.length; i++) {
            a3 = result;
            result = a1 > a2 ? a1 : a2;
            result = result + nums[i];
            a1 = a2;
            a2 = a3;
        }
        return result > a3 ? result : a3;
    }


    /**
     * 213. 打家劫舍 II
     * 你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。
     * 同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
     * <p>
     * 给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
     * <p>
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/house-robber-ii
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     *
     * @param nums
     * @return
     */
    public int rob2(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int nums1[] = new int[nums.length - 1];
        for (int i = 0; i < nums.length - 1; i++) {
            nums1[i] = nums[i];
        }
        int nums2[] = new int[nums.length - 1];
        for (int i = 1; i < nums.length; i++) {
            nums2[i - 1] = nums[i];
        }
        verifyBoolean flagAF = new verifyBoolean(false);
        verifyBoolean flagAL = new verifyBoolean(false);
        verifyBoolean flagBF = new verifyBoolean(false);
        verifyBoolean flagBL = new verifyBoolean(false);
        int result1 = rob3(nums1, flagAF, flagAL);
        if (!flagAF.value && !flagAL.value) {
            result1 = result1 + nums[nums.length - 1];
        }
        int result2 = rob3(nums2, flagBF, flagBL);
        if (!flagBL.value && !flagBF.value) {
            result2 = result2 + nums[0];
        }
        return Math.max(result1, result2);
    }

    class verifyBoolean {
        verifyBoolean(Boolean val) {
            this.value = val;
        }

        public Boolean value;
    }

    /**
     * @param nums
     * @param useFirst 用来记录第一个位置否使用
     * @param userLast 用来记录最后一个位置是否使用
     * @return
     */
    public int rob3(int[] nums, verifyBoolean useFirst, verifyBoolean userLast) {
        if (nums.length == 1) {
            useFirst.value = true;
            userLast.value = true;
            return nums[0];
        }
        int a1 = nums[0];
        int a2 = nums[1];
        int a3 = 0;
        int result = 0;
        if (nums.length == 2) {
            if (a1 > a2) {
                useFirst.value = true;
            } else {
                userLast.value = true;
            }
            return a1 > a2 ? a1 : a2;
        }
        if (nums.length == 3) {
            a3 = a1 + nums[2] > a2 ? a1 + nums[2] : a2;
            if (a1 + nums[2] > a2) {
                useFirst.value = true;
                userLast.value = true;
            } else {
                useFirst.value = false;
                userLast.value = false;
            }
            result = a3;
            return a3;
        }
        a3 = a1 + nums[2] > a2 ? a1 + nums[2] : a2;
        result = a3;
        for (int i = 3; i < nums.length; i++) {
            a3 = result;
            result = a1 > a2 ? a1 : a2;
            result = result + nums[i];
            a1 = a2;
            a2 = a3;
        }
        if (nums[0] + nums[2] > nums[1] + nums[3] || nums[0] + nums[3] > nums[1] + nums[2]) {
            useFirst.value = true;
        } else {
            useFirst.value = false;
        }
        if (result > a3) {
            userLast.value = true;
        } else {
            userLast.value = false;
        }
        if (nums[0] + nums[2] == nums[1] + nums[3] && nums.length == 4) {
            userLast.value = true;
            useFirst.value = false;
        }
        int resultLast = result > a3 ? result : a3;
        return resultLast;
    }

    public int test(Boolean fl) {
        fl = true;
        return 1;
    }

    /**
     * 740. 删除并获得点数
     * 给你一个整数数组 nums ，你可以对它进行一些操作。
     * <p>
     * 每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。
     * <p>
     * 开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
     * <p>
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/delete-and-earn
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     */
    public int deleteAndEarn(int[] nums) {
        int result = 0;
        Arrays.sort(nums);
        //计算每个值重复的次数
        int duplicateCount0 = 0;
        //num.get(0)存数字的值，num.get(1)存数字的值*数字出现的次数
        List<Integer> num1 = new LinkedList<Integer>();
        num1.add(0);
        List<Integer> num2 = new LinkedList<Integer>();
        num2.add(0);
        List<Integer> num3 = new LinkedList<Integer>();
        num3.add(0);
        List<Integer> num4 = new LinkedList<Integer>();
        num4.add(0);
        //遍历一边数组即可得到结果，i为遍历的index
        int i = 0;
        for (int j = 0; j < 2; j++) {
            while (i + 1 < nums.length && nums[i] == nums[i + 1]) {
                duplicateCount0++;
                i++;
            }
            if (j == 0) {
                //初始化num1
                duplicateCount0++;
                num1.set(0, nums[i]);
                num1.add(duplicateCount0 * nums[i]);
                i++;
            } else {
                //初始化num2
                if (i >= nums.length) {
                    return num1.get(1);
                }
                duplicateCount0++;
                num2.set(0, nums[i]);
                if (num2.get(0) > num1.get(0) + 1) {
                    num2.add(duplicateCount0 * nums[i] + num1.get(1));
                } else {
                    num2.add(duplicateCount0 * nums[i]);
                }
                i++;
            }
            duplicateCount0 = 0;
        }
        //特殊情况下的返回
        if (num1.get(1) == 0) {
            result = 0;
            return result;
        } else if (num2.get(1) == 0) {
            result = num1.get(1);
            return result;
        } else if (i == nums.length) {
            result = Math.max(num1.get(1), num2.get(1));
            return result;
        }
        //初始化num3
        while (i + 1 < nums.length && nums[i] == nums[i + 1]) {
            duplicateCount0++;
            i++;
        }
        duplicateCount0++;
        if (nums[i] == num2.get(0) + 1) {
            num3.set(0, nums[i]);
            num3.add(Math.max(num1.get(1) + nums[i] * duplicateCount0, num2.get(1)));
        } else if (nums[i] > num2.get(0) + 1) {
            num3.set(0, nums[i]);
            num3.add(Math.max(num1.get(1), num2.get(1)) + nums[i] * duplicateCount0);
        }
        i++;
        duplicateCount0 = 0;
        //特殊情况下的返回
        if (i >= nums.length) {
            return Math.max(num3.get(1), num2.get(1));
        }
        //滑动窗口num1, num2, num3, num4解剩下的值
        for (; i < nums.length; ) {
            while (i + 1 < nums.length && nums[i] == nums[i + 1]) {
                duplicateCount0++;
                i++;
            }
            if (i + 1 <= nums.length) {
                duplicateCount0++;
                if (nums[i] == num3.get(0) + 1) {
                    num4.set(0, nums[i]);
                    if (num4.size() > 1) {
                        num4.set(1, Math.max(num1.get(1), num2.get(1)) + nums[i] * duplicateCount0);
                    } else {
                        num4.add(Math.max(num1.get(1), num2.get(1)) + nums[i] * duplicateCount0);
                    }
                } else if (nums[i] > num3.get(0) + 1) {
                    num4.set(0, nums[i]);
                    if (num4.size() > 1) {
                        num4.set(1, nums[i] * duplicateCount0 + Math.max(num3.get(1), num2.get(1)));
                    } else {
                        num4.add(nums[i] * duplicateCount0 + Math.max(num3.get(1), num2.get(1)));
                    }
                }
                i++;
            } else {
                num4 = num3;
                i++;
            }
            duplicateCount0 = 0;
            result = Math.max(num3.get(1), num4.get(1));
            num1 = num2;
            num2 = num3;
            num3 = num4;
            num4 = new LinkedList<Integer>();
            num4.add(0);
        }
        return result;
    }

    /**
     * 53. 最大子数组和
     * 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
     * 子数组 是数组中的一个连续部分。
     *
     * @param nums
     * @return
     */
    public int maxSubArray(int[] nums) {
        //存储最大值
        int result = nums[0];
        int childStrSum = 0;
        for (int i = 0; i < nums.length; i++) {
            childStrSum = childStrSum + nums[i];
            result = Math.max(result, childStrSum);
            if (childStrSum < 0) {
                childStrSum = 0;
            }
        }
        return result;
    }

    public int maxSubarraySumCircular(int[] nums) {
        int result = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            int[] first = Arrays.copyOfRange(nums, 0, i);
            int[] last = Arrays.copyOfRange(nums, i, nums.length);
            int[] resRange = Arrays.copyOf(last, nums.length);
            System.arraycopy(first, 0, resRange, last.length, first.length);
            result = Math.max(result, maxSubArray(resRange));
        }
        return result;
    }

    /**
     * 413. 等差数列划分
     * 如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。
     * <p>
     * 例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
     * 给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。
     * <p>
     * 子数组 是数组中的一个连续序列。
     */
    public int numberOfArithmeticSlices(int[] nums) {
        int result = 0;
        if (nums.length < 3) {
            return result;
        }
        int num1 = nums[0];
        int num2 = nums[1];
        //一组等差数列的最大长度
        int lenth = 2;
        for (int i = 2; i < nums.length; i++) {
            if (nums[i] - num2 == num2 - num1) {
                lenth++;
            }
            if (nums[i] - num2 != num2 - num1 || i == nums.length - 1) {
                if (lenth > 2) {
                    int a = lenth - 2;
                    result = result + (1 + a) * a / 2;//高斯数列求和
                    lenth = 2;
                }
            }
            num1 = num2;
            num2 = nums[i];
        }
        return result;
    }

    /**
     * 91. 解码方法
     */
    public int numDecodings(String s) {
        //连着两个0的情况直接返回0，代表编码错误
        for (int i = 0; i < s.length() - 1; i++) {
            if (s.charAt(i) == '0' && s.charAt(i + 1) == '0' || s.charAt(i) > '2' && s.charAt(i + 1) == '0') {
                return 0;
            }
        }
        while (s.startsWith("0")) {
            return 0;
        }
        int ans = 1;
        if (s.length() <= 1) {
            return ans;
        }
        //滑动窗口头位置
        int begin = 0;
        //滑动窗口尾位置
        int end = 1;
        begin = findBeginAndEnd(0, s);
        end = begin + 1;
        //装每一段字符串的可能的解码种数
        List<Integer> partNums = new LinkedList<Integer>();
        while (true) {
            if (begin < 0 || begin >= s.length() || end >= s.length()) {
                partNums.add(countPartAns(begin, end, s));
                break;
            }
            if (s.charAt(end) > '6') {
                //最后一位大于6，直接刨除
                if (s.charAt(end - 1) != '1') {
                    end--;
                }
                partNums.add(countPartAns(begin, end, s));
                begin = findBeginAndEnd(end + 1, s);
                end = begin + 1;
                continue;
            } else if (s.charAt(end) > '2' && s.charAt(end) <= '6') {
                //倒数第二位数字是2、最后一位数字最多是6
                partNums.add(countPartAns(begin, end, s));
                begin = findBeginAndEnd(end + 1, s);
                end = begin + 1;
                continue;
            } else if (s.charAt(end) == '0') {
                //遇到最后一位是0， 需要end往前退2位
                int temp = end;
                end = end - 2;
                partNums.add(countPartAns(begin, end, s));
                begin = findBeginAndEnd(temp + 1, s);
                end = begin + 1;
                continue;
            }
            end++;
        }
        for (Integer each : partNums) {
            ans = ans * each;
        }
        return ans;
    }

    //返回负的代表beginIndex对于s字符串已经越界了
    private int findBeginAndEnd(int beginIndex, String s) {
        int ans = -10;
        for (int i = beginIndex; i < s.length(); i++) {
            //确定滑动窗口头、尾位置
            if (s.charAt(i) == '2' || s.charAt(i) == '1') {
                ans = i;
                break;
            }
        }
        return ans;
    }

    //计算每一小段的可能的解码种数
    private Integer countPartAns(int beginIndex, int endIndex, String s) {
        //越界了或者出现了不该出现的情况
        if (endIndex <= beginIndex || beginIndex < 0) {
            return 1;
        }
        if (endIndex >= s.length()) {
            endIndex = s.length() - 1;
        }
        Integer ans = 1;
        int num1 = 1;
        int num2 = 2;
        int num3 = 0;
        if (endIndex == beginIndex) {
            return 1;
        }
        if (endIndex - beginIndex == 2) {
            return 3;
        }
        if (endIndex - beginIndex == 1) {
            return 2;
        }
        for (int i = beginIndex + 2; i <= endIndex; i++) {
            //动态规划爬楼梯思想
            num3 = num2 + num1;
            num1 = num2;
            num2 = num3;
        }
        ans = num3;
        return ans;
    }

    /**
     * 221. 最大正方形
     * 在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。
     * 注意点：这道题关键点在于 dp(i,j) = min(dp(i−1,j),dp(i−1,j−1),dp(i,j−1)) + 1。能把这个递推公式想出来这道题就解完了
     */
    public int maximalSquare(char[][] matrix) {
        int ans = 0;
        char[][] copy = new char[matrix.length][matrix[0].length];
        for (int j = 0; j < matrix[0].length; j++) {
            if (matrix[0][j] == '1') {
                ans = 1;
            }
            copy[0][j] = matrix[0][j];
        }
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[i][0] == '1') {
                ans = 1;
            }
            copy[i][0] = matrix[i][0];
        }
        for (int i = 1; i < matrix.length; i++) {
            for (int j = 1; j < matrix[i].length; j++) {
                if (copy[i - 1][j] != '0' && copy[i][j - 1] != '0' && copy[i - 1][j - 1] != '0' && matrix[i][j] != '0') {
                    copy[i][j] = (char) (Math.min(Math.min(copy[i - 1][j] - '0', copy[i][j - 1] - '0'), copy[i - 1][j - 1] - '0') + 1 + 48);
                    ans = Math.max(ans, (copy[i][j] - '0') * (copy[i][j] - '0'));
                } else {
                    copy[i][j] = matrix[i][j];
                    ans = Math.max(ans, (copy[i][j] - '0') * (copy[i][j] - '0'));
                }
            }
        }
        return ans;
    }

    @Test
    public void testTwoSum() {

    }

    /**
     * 1. 两数之和
     * 已解答
     * 简单
     * 相关标签
     * 相关企业
     * 提示
     * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
     * <p>
     * 你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
     * <p>
     * 你可以按任意顺序返回答案。
     */
    public int[] twoSum(int[] nums, int target) {
        if (nums.length < 2) {
            return new int[]{};
        }
        int[] result = null;
        boolean flag = false;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (target == nums[i] + nums[j]) {
                    result = new int[]{i, j};
                    flag = true;
                    break;
                }
            }
            if (flag) {
                break;
            }
        }
        return result;
    }
    /**
     * 上题的哈希解法
     */
    public int[] twoSum2(int[] nums, int target) {
        HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (hashMap.containsKey(target - nums[i])) {
                return new int[]{i, hashMap.get(target - nums[i]).intValue()};
            }else{
                hashMap.put(nums[i], i);
            }
        }
        return new int[]{};
    }
}
